// packageA/pages/stepChart/stepChart.js
const app = getApp();
import CommonService from '../../../utils/service/commonService.js';
import Toast from '../../../miniprogram_npm/@vant/weapp/toast/toast';
import * as echarts from '../../../ec-canvas/echarts';
const util = require('../../../utils/util');
//去掉尾部的0
const regexp = /(?:\.0*|(\.\d+?)0+)$/;
//图表对象
let Chart = null;
// 定义蓝色渐变颜色（从浅到深）
const intensityColors = [
  '#F0F8FF', // 淡天蓝色 - 超低强度
  '#87CEEB', // 天蓝色 - 低强度
  '#5F9EA0', // 宝蓝色 - 中强度
  '#0066CC'  // 深海蓝 - 高强度
];
Page({

    /**
     * 页面的初始数据
     */
    data: {
        //传参
        paramObj: null,
        //图表
        ec: {
            //延迟加载
            lazyLoad: true
        },
        //是否显示图表（避免遮挡）
        showChart: true,
        //无数据
        showNoData: true,
        //图表配置
        chartSet: {
            //轴上标题
            ytitle: '活跃度',
            xtitle: '时间',
        },
        //今日日期
        todayDate: util.timeFormatDay(new Date()),
        //日期选择框
        showDate: false,
        currentDate: new Date().getTime(),
        minDate: new Date().getTime(),
        maxDate: new Date().getTime(),
        formatter(type, value) {
            if (type === 'year') {
                return `${value}年`;
            } else if (type === 'month') {
                return `${value}月`;
            }
            return value;
        },
        //显示的日期
        currentDateStr: util.timeFormatDay(new Date()),
        //日统计到几天前
        dayNum: 31,
        //今日步数合计
        total: 0,
        dataType:"",
        describe:"",
        echartsData: []
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad: function (options) {
        //设置统计的最小日期
        this.getBeforeDate();

        if (options.paramObj) {
            let paramObj = JSON.parse(options.paramObj);
            console.log('步数传参');
            console.log(paramObj);

            this.setData({
                paramObj: paramObj,
                dataType:paramObj.dataType
            })

            if(paramObj.dataType=="work"){
              this.setData({
                describe:"有效工作时长",
                chartSet:{
                  ytitle: '时长',
                  xtitle: '时间',
                }
            })
            }else if (paramObj.dataType=="step"){
              this.setData({
                describe:"有效活跃度",
                chartSet:{
                  ytitle: '活跃度',
                  xtitle: '时间',
                }
            })
            }

            if (paramObj.date) {
                this.setData({
                    currentDateStr: paramObj.date
                })
            }

            if (paramObj.workOverStartTime && paramObj.workOverEndTime) {
                wx.setNavigationBarTitle({
                    title: '加班时段活跃度统计'
                })
            }

            //获取步数数据
            this.getChartData();
        }
    },

    //获取步数数据
    getChartData() {
        //图表组件
        this.echartsComponnet = this.selectComponent('#mychart');
        let pObj = this.data.paramObj;

        this.setData({
            showNoData: false,
            showChart: true
        })
        let nowStr = util.timeFormatDay(new Date())
        let param = {
            imei: pObj.imei,
            startDate: this.data.currentDateStr+"T00:00:00.000Z",
            endDate:this.data.currentDateStr+"T23:59:59.000Z",
        }
        console.log(param);
        CommonService.effectiveDetail(param).then(res => {
            if (res.data) {
              // let result = res.data
               let result = []
                let total = 0
                if ( res.data.length) {
                  const dataCopy = JSON.parse(JSON.stringify( res.data)); // 深拷贝原始数据
                  result = this.processIntensityData(dataCopy);
                  console.log(result);
                
                    console.log('今日步数');
                    if (this.data.dataType == "work"){
                      result.forEach(element => {
                        total += element.total_duration;
                    });
                    total = (total/60).toFixed(2)
                    }else if(this.data.dataType == "step"){
                      result.forEach(element => {
                        total += element.total_steps;
                    });
                    }
                   
                    this.setData({
                        total: total
                    })
                    let xDataArr = new Map([
                                        [1, '超低强度'],
                                        [2, '低强度'],
                                        [3, '中强度'],
                                        [4, '高强度']
                                      ]);
                    console.log(xDataArr);
                    const intensityList = Array.from(xDataArr.values()); // 获取强度中文名称列表：['超低强度', '低强度', '中强度', '高强度']
                    const hourDataMap = new Map(); // 按小时分组存储数据
                    console.log(intensityList);
                  
                    // 1. 按小时分组，按强度汇总 duration
                    result.forEach(item => {
                      const { hour, intensity_details } = item;
                      const hourKey = hour;
                      
                      // 初始化小时数据
                      if (!hourDataMap.has(hourKey)) {
                        hourDataMap.set(hourKey, {
                          [1]: 0, // 超低强度
                          [2]: 0, // 低强度
                          [3]: 0, // 中强度
                          [4]: 0  // 高强度
                        });
                      }
                    
                      // 汇总每个强度的 duration
                      intensity_details.forEach(detail => {
                        const intensity = detail.intensity;
                        let durationas = 0
                        if (this.data.dataType == "work"){
                          durationas = detail.duration;
                        }else if (this.data.dataType == "step"){
                          durationas = detail.steps;
                        }
                      
                        hourDataMap.get(hourKey)[intensity] += durationas;
                      });
                     
                    });
                    // 2. 转换为 ECharts 所需的数组格式（按小时顺序排列）
                      let hours = Array.from(hourDataMap.keys()).sort((a, b) => a - b); // 按小时升序排列
                      const seriesData = [];
                    
                     
                      // 3. 为每个强度等级生成一个 series
                      intensityList.forEach((intensityName, index) => {
                        const intensityKey = index + 1; // 强度数字（1-4）与列表索引对应
                       
                        const data = hours.map(hour => {
                          return hourDataMap.get(hour)[intensityKey];
                        });
                       
                        seriesData.push({
                          name: intensityName, // 强度中文名称（如 '低强度'）
                          type: 'bar',
                          barWidth: "50%",
                          stack: 'total',
                          label: { show: false },
                          itemStyle: {
                            color: intensityColors[index] // 设置固定颜色
                          },
                          data: data
                        });
                      });

                      let totalData = hours.map((_, index) => {
                        return seriesData.reduce((sum, item) => sum + item.data[index], 0);
                      });

                      if (this.data.dataType == "work"){
                        seriesData.push({
                          name: "", // 强度中文名称（如 '低强度'）
                          type: 'bar',
                          barWidth: "45%",
                          barGap: '-100%',
                          z: 9, // 设置z-index为-1，使其位于其他柱状图的后面
                          label: {
                            show: true,
                            position: "right", // 总数显示在右方
                            color: "#04071E",
                            fontSize: 13,
                            formatter: function(params) {
                                return `${totalData[params.dataIndex]}分钟`; // 仅显示总数
                            },
                        
                          },
                          itemStyle: {
                            color: "transparent" // 不需要柱子的颜色
                          },
                          data: totalData // 显示每组的总数
                        })
                      }else{
                        seriesData.push({
                          name: "", // 强度中文名称（如 '低强度'）
                          type: 'bar',
                          barWidth: "45%",
                          barGap: '-100%',
                          z: -1, // 设置z-index为-1，使其位于其他柱状图的后面
                          label: {
                            show: true,
                            position: "right", // 总数显示在右方
                            color: "#04071E",
                            fontSize: 14,
                            
                            formatter: function(params) {
                                return `${totalData[params.dataIndex]}`; // 仅显示总数
                            }
                          },
                          itemStyle: {
                            color: "transparent" // 不需要柱子的颜色
                          },
                          data: totalData // 显示每组的总数
                        })
                      }

                      let last = hours[hours.length-1];
                      hours.push(last+1)
                    let chartData = {
                      yAxisDate:hours,
                      data:seriesData,
                      lengArr:intensityList
                    }
                    console.log(chartData);
                    
                    //判断图表是否第一次绘制
                    this.isHaveChart(Chart, this.echartsComponnet, this.data.chartSet, chartData);

                } else {
                    this.setData({
                        showNoData: true,
                        showChart: false
                    })
                }

            } else {
                this.setData({
                    showNoData: true,
                    showChart: false
                })
            }
        })
    },


    processIntensityData(data) {
      // 按时间顺序排序（确保从早到晚处理）
      const sortedData = [...data].sort((a, b) => a.hour - b.hour); // 复制副本避免修改原始数组
    
      for (let i = 0; i < sortedData.length; i++) {
        const current = sortedData[i];
        let currentTotal = 0;
        
        // 1. 计算当前时间点原始总时长（校验用）
        current.intensity_details.forEach(item => {
          currentTotal += item.duration;
        });
        if (currentTotal <= 60) continue; // 原始总时长未超过60，跳过
        
        // 2. 计算差值并处理
        let excess = currentTotal - 60;
        let prevIndex = i - 1; // 前一个时间点索引
        console.log("current");
        console.log(current);
      
        while (excess > 0 && prevIndex >= 0) {
          current.intensity_details[0].duration = current.intensity_details[0].duration-excess
          const prev = sortedData[prevIndex];
          let intensity2Item = prev.intensity_details.find(item => item.intensity === 2);
          
          if (intensity2Item) {
            // 存在强度2，增加时长并更新前一个时间点的总时长
            const prevOriginalTotal = prev.intensity_details.reduce((sum, item) => sum + item.duration, 0);
            const newDuration = intensity2Item.duration + excess;
            const newTotal = prevOriginalTotal + excess;
            
            intensity2Item.duration = newDuration;
            prev.total_duration = newTotal; // 更新总时长
            
            // 检查前一个时间点是否超限
            if (newTotal > 60) {
              excess = newTotal - 60; // 剩余差值
              intensity2Item.duration = 60 - (prevOriginalTotal - intensity2Item.duration); // 恢复前一个时间点到60分钟
              prev.total_duration = 60; // 强制总时长为60
            } else {
              excess = 0; // 差值消耗完毕
            }
          } else {
            // 不存在强度2，新增记录
            prev.intensity_details.push({
              intensity: 2,
              duration: excess,
              steps: 0 // 步数默认0，可根据需求处理
            });
            prev.total_duration += excess; // 更新总时长
            excess = 0; // 差值消耗完毕
          }
          
          prevIndex--; // 向前递归
        }
        
        // 3. 强制当前时间点总时长为60（超出部分已全部转移）
        current.intensity_details = current.intensity_details.map(item => {
          if (item.intensity === 2 && excess > 0) {
            // 理论上excess已耗尽，此处为防御性代码
            const delta = item.duration - excess;
            item.duration = delta > 0 ? delta : 0;
            excess = 0;
          }
          return item;
        });
        current.total_duration = 60; // 确保当前总时长为60
      }
      
      return sortedData; // 返回处理后的数组（结构与原始一致）
    },
    
    generateNumberArray(start, end) {
      const result = [];
      for (let i = start; i <= end; i++) {
        result.push(i);
      }
      return result;
    },
    //显示日期选择框
    onShowDate() {
        //加班跳转来的不能切换日期
        if (!this.data.paramObj.workOverStartTime) {
            this.setData({
                showDate: true
            })
            //隐藏图表
            this.hideChart();
        }
    },

    //关闭日期选择框
    onCloseDate() {
        this.setData({
            showDate: false
        })
        //显示图表
        this.showChart();
    },

    //确定日期时
    onConfirmDate(event) {
        this.setData({
            currentDate: event.detail,
            currentDateStr: util.timeFormatDay(event.detail)
        })

        //关闭日期选择框
        this.onCloseDate();

        //获取步数数据
        this.getChartData();
    },

    //设置日统计的最小日期
    getBeforeDate() {
        let rusult = util.countPrevDay(new Date(), this.data.dayNum);
        this.setData({
            minDate: rusult
        });
    },

    //判断图表是否第一次绘制
    isHaveChart(chartObj, componnetObj, setObj, dataObj) {
        if (!chartObj) {
            //如果是第一次绘制，则初始化图表
            this.init_echarts(chartObj, componnetObj, setObj, dataObj);
        } else {
            //更新图表数据
            this.setOption(chartObj, setObj, dataObj);
        }
    },

    //初始化图表
    init_echarts: function (chartObj, componnetObj, setObj, dataObj) {
        componnetObj.init((canvas, width, height) => {
            chartObj = echarts.init(canvas, null, {
                width: width,
                height: height
            });

            this.setOption(chartObj, setObj, dataObj);

            return chartObj;
        });
    },

    //更新图表数据
    setOption: function (chartObj, setObj, dataObj) {
        //清除
        chartObj.clear();
        //设置新数据
        chartObj.setOption(this.getOption(chartObj, setObj, dataObj));
    },

    //指定图表的配置项和数据
    getOption: function (chartObj, setObj, dataObj) {
        let option = {
         
          tooltip: {
            trigger: 'axis',
            axisPointer: {
              // Use axis to trigger tooltip
              type: 'shadow' // 'shadow' as default; can also be 'line' or 'shadow'
            }
          },
            legend: {
                left:'13%',
                top:'6%',
                x: 'right',
                y: '-17'
            },
            grid: {
              left: '2%',
             // right: '4%',
              bottom: '3%',
              containLabel: true,
              width:'83%'
            },
            xAxis: {
              type: 'value',
              name: setObj.ytitle,
              axisLabel: {
                textStyle: {
                    fontSize: 14,  // 设置 Y 轴字体大小（单位：px）
                }
            }
            },
            yAxis: {
              type: 'category',
              name: setObj.xtitle,
              data: dataObj.yAxisDate,
              nameTextStyle: { // 坐标轴名称的字体样式
                fontSize: 14,
              },
              axisLabel: {
                interval: 0,
                textStyle: {
                    fontSize: 14,  // 设置 Y 轴字体大小（单位：px）
                },
                padding: [44, 0, 0, 0]
              
            },
            axisTick: {
              //轴线与数据字段对齐
              alignWithLabel: false
            },
            },
            series: dataObj.data
        };

        return option;
    },

    //隐藏图表
    hideChart() {
        this.setData({
            showChart: false
        })
    },

    //显示图表
    showChart() {
        this.setData({
            showChart: true
        })
    },

    /**
     * 生命周期函数--监听页面初次渲染完成
     */
    onReady: function () {

    },

    /**
     * 生命周期函数--监听页面显示
     */
    onShow: function () {

    },

    /**
     * 生命周期函数--监听页面隐藏
     */
    onHide: function () {

    },

    /**
     * 生命周期函数--监听页面卸载
     */
    onUnload: function () {

    },

    /**
     * 页面相关事件处理函数--监听用户下拉动作
     */
    onPullDownRefresh: function () {

    },

    /**
     * 页面上拉触底事件的处理函数
     */
    onReachBottom: function () {

    }
})